home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Think Class Libraries / TP TCL->CW TCL v1.1.2.3 / UPI ƒ / Updated UPIs ƒ / fp.p < prev    next >
Text File  |  1996-02-07  |  21KB  |  436 lines
  1. {
  2.      File:        fp.p
  3.  
  4.      Copyright:    © 1994-1995 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Pascal, March 29, 1995 
  8.     
  9.     Note:        The following file was hand converted from fp.h
  10.                 See fp.h for more information and comments.
  11. }
  12.  
  13.  
  14. {$IFC UNDEFINED UsingIncludes}
  15. {$SETC UsingIncludes := 0}
  16. {$ENDC}
  17.  
  18. {$IFC NOT UsingIncludes}
  19.  UNIT fp;
  20.  INTERFACE
  21. {$ENDC}
  22.  
  23. {$IFC UNDEFINED __FP__}
  24. {$SETC __FP__ := 1}
  25.  
  26. {$I+}
  27. {$SETC fpIncludes := UsingIncludes}
  28. {$SETC UsingIncludes := 1}
  29.  
  30. {$IFC UNDEFINED __TYPES__}
  31. {$I Types.p}
  32. {$ENDC}
  33.  
  34. CONST
  35.     DOUBLE_SIZE                    = 8;
  36.  
  37. {$IFC GENERATINGPOWERPC }
  38.     LONG_DOUBLE_SIZE            = 16;
  39.     DECIMAL_DIG                    = 17;  { does not exist for double-double }
  40. {$ELSEC}
  41.     DECIMAL_DIG                    = 21;
  42. {$IFC GENERATING68881}
  43.     LONG_DOUBLE_SIZE            = 12;
  44. {$ELSEC}
  45.     LONG_DOUBLE_SIZE            = 10;
  46. {$ENDC}
  47. {$ENDC}
  48.  
  49. {$J+}    {MWERKS adding pi, defined in mathlib}
  50. VAR
  51.     pi: double_t;
  52. {$J-}
  53.  
  54. (*******************************************************************************
  55. *                            Trigonometric functions                           *
  56. *******************************************************************************)
  57.  
  58. FUNCTION cos(x: double_t): double_t; C; EXTERNAL;
  59. FUNCTION sin(x: double_t): double_t; C; EXTERNAL;
  60. FUNCTION tan(x: double_t): double_t; C; EXTERNAL;
  61.  
  62. FUNCTION acos(x: double_t): double_t; C; EXTERNAL;
  63. FUNCTION asin(x: double_t): double_t; C; EXTERNAL;
  64. FUNCTION atan(x: double_t): double_t; C; EXTERNAL;
  65.     { atan2 computes the arc tangent of y/x in [-pi,pi] using the sign of both }
  66.     { arguments to determine the quadrant of the computed value. }
  67. FUNCTION atan2(y: double_t; x: double_t): double_t; C; EXTERNAL;
  68.  
  69. (*******************************************************************************
  70. *                              Hyperbolic functions                            *
  71. *******************************************************************************)
  72.  
  73. FUNCTION cosh(x: double_t): double_t; C; EXTERNAL;
  74. FUNCTION sinh(x: double_t): double_t; C; EXTERNAL;
  75. FUNCTION tanh(x: double_t): double_t; C; EXTERNAL;
  76. FUNCTION acosh(x: double_t): double_t; C; EXTERNAL;
  77. FUNCTION asinh(x: double_t): double_t; C; EXTERNAL;
  78. FUNCTION atanh(x: double_t): double_t; C; EXTERNAL;
  79.  
  80. (*******************************************************************************
  81. *                              Exponential functions                           *
  82. *******************************************************************************)
  83.  
  84. FUNCTION exp(x: double_t): double_t; C; EXTERNAL;
  85.     { expm1 computes the base e exponential of the argument minus 1, i. e., exp(x) - 1. }
  86.     { For small enough arguments, expm1 is expected to be more accurate than the straight }
  87.     { forward computation of exp(x) - 1.}
  88. FUNCTION expm1(x: double_t): double_t; C; EXTERNAL;
  89.     { exp2 computes the base 2 exponential. }
  90. FUNCTION exp2(x: double_t): double_t; C; EXTERNAL;
  91. FUNCTION frexp(x: double_t; VAR exponent: LONGINT): double_t; C; EXTERNAL;
  92. FUNCTION ldexp(x: double_t; n: LONGINT): double_t; C; EXTERNAL;
  93. FUNCTION log(x: double_t): double_t; C; EXTERNAL;
  94.     { log2 computes the base 2 logarithm. }
  95. FUNCTION log2(x: double_t): double_t; C; EXTERNAL;
  96.     { log1p computes the base e logorithm of 1 plus the argument, i. e., log (1 x).  For small }
  97.     { enough arguments, log1p is expected to be more accurate than the straightforward computation }
  98.     { of log (1+x). }
  99. FUNCTION log1p(x: double_t): double_t; C; EXTERNAL;
  100. FUNCTION log10(x: double_t): double_t; C; EXTERNAL;
  101.     { logb extracts the exponent of its argument, as a signed integral value. A subnormal argument }
  102.     { is treated as though it were first normalized. Thus 1 <= x  2^( - Logb ( x ) ) < 2 }
  103. FUNCTION logb(x: double_t): double_t; C; EXTERNAL;
  104. FUNCTION modf(x: Double; VAR iptr: Double): Double; C; EXTERNAL;
  105. FUNCTION modff(x: Single; VAR iptrf: Single): Single; C; EXTERNAL;
  106.     { scalb computes x  2^n efficently.  This is not normally done by computing 2^n explicitly. }
  107. FUNCTION scalb(x: double_t; n: LONGINT): double_t; C; EXTERNAL;
  108.  
  109. (*******************************************************************************
  110. *                     Power and absolute value functions                       *
  111. *******************************************************************************)
  112.  
  113. FUNCTION fabs(x: double_t): double_t; C; EXTERNAL;
  114. { hypot computes the square root of the sum of the squares of its arguments, without undue overflow or underflow. }
  115. FUNCTION hypot(x: double_t; y: double_t): double_t; C; EXTERNAL;
  116. FUNCTION pow(x: double_t; y: double_t): double_t; C; EXTERNAL;
  117. FUNCTION sqrt(x: double_t): double_t; C; EXTERNAL;
  118.  
  119. (*******************************************************************************
  120. *                        Gamma and Error functions                             *
  121. *******************************************************************************)
  122.  
  123. FUNCTION erf(x: double_t): double_t; C; EXTERNAL;
  124. FUNCTION erfc(x: double_t): double_t; C; EXTERNAL;    {   complementary error function   }
  125. FUNCTION gamma(x: double_t): double_t; C; EXTERNAL;
  126. { lgamma computes the base-e logarithm of the absolute value of gamma of its argument x, for x > 0. }
  127. FUNCTION lgamma(x: double_t): double_t; C; EXTERNAL;
  128.  
  129. (*******************************************************************************
  130. *                        Nearest integer functions                             *
  131. *******************************************************************************)
  132.  
  133. FUNCTION ceil(x: double_t): double_t; C; EXTERNAL;
  134. FUNCTION floor(x: double_t): double_t; C; EXTERNAL;
  135.     { the rint function rounds its argument to an integral value in floating point format, }
  136.     { honoring the current rounding direction. }
  137. FUNCTION rint(x: double_t): double_t; C; EXTERNAL;
  138.     { nearbyint differs from rint only in that it does not raise the inexact exception. It }
  139.     { is the nearbyint function recommended by the IEEE floating-point standard 854. }
  140. FUNCTION nearbyint(x: double_t): double_t; C; EXTERNAL;
  141.     { the function rinttol rounds its argument to the nearest long using the current rounding }
  142.     { direction. Note that if the rounded value is outside the range of long, then the result }
  143.     { is undefined. }
  144. FUNCTION rinttol(x: double_t): LONGINT; C; EXTERNAL;
  145.     { the round function rounds the argument to the nearest integral value in double format }
  146.     { similar to the Fortran "anint" function.  That is: add half to the magnitude and chop. }
  147. FUNCTION round(x: double_t): double_t; C; EXTERNAL;
  148.     { roundtol is similar to the Fortran function nint or to the Pascal round. Note that if the }
  149.     { rounded value is outside the range of long, then the result is undefined. }
  150. FUNCTION roundtol(round: double_t): LONGINT; C; EXTERNAL;
  151.     { trunc computes the integral value, in floating format, nearest to but no larger in magnitude }
  152.     { than its argument. }
  153. {MWERKS}
  154. {$IFC GENERATING68K}
  155.     FUNCTION trunc(x: double_t): INTEGER; C; EXTERNAL;
  156. {$ELSEC}
  157.     FUNCTION trunc(x: double_t): double_t; C; EXTERNAL;
  158. {$ENDC}
  159.  
  160. (*******************************************************************************
  161. *                            Remainder functions                               *
  162. *******************************************************************************)
  163.  
  164. { the following two functions compute the remainder.  remainder is required by the IEEE 754 }
  165. { floating point standard. The second form correponds to the SANE remainder; it stores into }
  166. { 'quotient' the 7 low-order bits of the integer quotient x/y, such that -127 <= quotient <= 127. }
  167. FUNCTION fmod(x: double_t; y: double_t): double_t; C; EXTERNAL;
  168. FUNCTION remainder(x: double_t; y: double_t): double_t; C; EXTERNAL;
  169. FUNCTION remquo(x: double_t; y: double_t; VAR quo: LONGINT): double_t; C; EXTERNAL;
  170.  
  171. (*******************************************************************************
  172. *                             Auxiliary functions                              *
  173. *******************************************************************************)
  174.  
  175. FUNCTION copysign(x: double_t; y: double_t): double_t; C; EXTERNAL;
  176. FUNCTION nan(tagp: ConstCStringPtr): Double; C; EXTERNAL;
  177. FUNCTION nanf(tagp: ConstCStringPtr): Single; C; EXTERNAL;
  178. FUNCTION nextafterd(x: Double; y: Double): Double; C; EXTERNAL;
  179. FUNCTION nextafterf(x: Single; y: Single): Single; C; EXTERNAL;
  180.  
  181. (*******************************************************************************
  182. *                      Max, Min and Positive Difference                        *
  183. *******************************************************************************)
  184.  
  185. {     These extension functions correspond to the standard functions, dim
  186.       max and min.
  187.  
  188.       The fdim function determines the 'positive difference' between its
  189.       arguments: ( x - y, if x > y ), ( +0, if x <= y ).  If one argument is
  190.       NaN, then fdim returns that NaN.  if both arguments are NaNs, then fdim
  191.       returns the first argument.                                             }
  192. FUNCTION fdim(x: double_t; y: double_t): double_t; C; EXTERNAL;
  193.  
  194. {    max and min return the maximum and minimum of their two arguments,
  195.       respectively.  They correspond to the max and min functions in FORTRAN.
  196.       NaN arguments are treated as missing data.  If one argument is NaN and
  197.       the other is a number, then the number is returned.  If both are NaNs
  198.       then the first argument is returned.                                    }
  199. FUNCTION fmax(x: double_t; y: double_t): double_t; C; EXTERNAL;
  200. FUNCTION fmin(x: double_t; y: double_t): double_t; C; EXTERNAL;
  201.  
  202. (*******************************************************************************
  203. *                              Inquiry functions                               *
  204. *******************************************************************************)
  205.  
  206. CONST
  207.     FP_SNAN     = 0;        {      signaling NaN                         }
  208.     FP_QNAN     = 1;        {      quiet NaN                             }
  209.     FP_INFINITE = 2;        {      + or - infinity                       }
  210.     FP_ZERO        = 3;        {      + or - zero                           }
  211.     FP_NORMAL    = 4;        {      all normal numbers                    }
  212.     FP_SUBNORMA = 5;        {      denormal numbers                      }
  213.  
  214. FUNCTION __fpclassifyd(x: Double): LONGINT; C; EXTERNAL;
  215. FUNCTION __fpclassifyf(x: Single): LONGINT; C; EXTERNAL;
  216. FUNCTION __isnormald(x: Double) : LONGINT; C; EXTERNAL;
  217. FUNCTION __isnormalf(x: Single): LONGINT; C; EXTERNAL;
  218. FUNCTION __isfinited(x: Double): LONGINT; C; EXTERNAL;
  219. FUNCTION __isfinitef(x: Single): LONGINT; C; EXTERNAL;
  220. FUNCTION __isnand(x: Double): LONGINT; C; EXTERNAL;
  221. FUNCTION __isnanf(x: Single): LONGINT; C; EXTERNAL;
  222. FUNCTION __signbitd(x: Double): LONGINT; C; EXTERNAL;
  223. FUNCTION __signbitf(x: Single): LONGINT; C; EXTERNAL;
  224. FUNCTION __inf: Double; C;  EXTERNAL; {MWERKS}
  225.  
  226. (*******************************************************************************
  227. *                              Non NCEG extensions                             *
  228. *******************************************************************************)
  229.  
  230. {$IFC UNDEFINED __NOEXTENSIONS__ }
  231.  
  232. (*******************************************************************************
  233. *                              Financial functions                             *
  234. *******************************************************************************)
  235.  
  236. {     compound computes the compound interest factor "(1 + rate) ^ periods"
  237.       more accurately than the straightforward computation with the Power
  238.       function.  This is SANE's compound function.                            }
  239. FUNCTION compound(rate: double_t; periods: double_t): double_t; C; EXTERNAL;
  240.  
  241. {    The function annuity computes the present value factor for an annuity 
  242.       "( 1 - ( 1 + rate ) ^ ( - periods ) ) / rate" more accurately than the
  243.       straightforward computation with the Power function. This is SANE's 
  244.       annuity function.                                                       }
  245. FUNCTION annuity(rate: double_t; periods: double_t): double_t; C; EXTERNAL;
  246.  
  247. (*******************************************************************************
  248. *                              Random function                                 *
  249. *******************************************************************************)
  250.  
  251. FUNCTION randomx(VAR x: double_t): double_t; C; EXTERNAL;
  252.  
  253. (*******************************************************************************
  254. *                              Relational operator                             *
  255. *******************************************************************************)
  256.  
  257. TYPE
  258.     relop = INTEGER;        {      relational operator      }
  259.  
  260. CONST
  261.     GREATERTHAN                    = 0;
  262.     LESSTHAN                    = 1;
  263.     EQUALTO                        = 2;
  264.     UNORDERED                    = 3;
  265.  
  266. FUNCTION relation(x: double_t; y: double_t): relop; C; EXTERNAL;
  267.  
  268. (*******************************************************************************
  269. *                         Binary to decimal conversions                        *
  270. *******************************************************************************)
  271.  
  272. CONST
  273. {$IFC GENERATINGPOWERPC }
  274.     SIGDIGLEN                    = 36;                    { significant decimal digits }
  275. {$ELSEC}
  276.     SIGDIGLEN                    = 20;                    { significant decimal digits }
  277. {$ENDC}
  278.     DECSTROUTLEN                = 80;                    { max length for dec2str output }
  279.  
  280. TYPE
  281.     DecimalKind = (FloatDecimal,FixedDecimal);
  282.  
  283. {     The decimal record type provides an intermediate unpacked form for
  284.       programmers who wish to do their own parsing of numeric input or
  285.       formatting of numeric output.                                         }
  286.     
  287.     {$ALIGN MAC68K}
  288.     Decimal = RECORD
  289.         sgn:     0..1;            { sign 0 for +, 1 for -  }
  290.         exp:     INTEGER;
  291.         sig:     STRING[SIGDIGLEN];
  292.     END;
  293.     {$ALIGN RESET}
  294.  
  295. {    Each conversion to a decimal string is controlled by a decform
  296.       structure.  The style is either FLOATDECIMAL or FIXEDDECIMAL defined
  297.       above.  The value of digits is the number of significant digits for
  298.       FLOATDECIMAL.  The value of digits for FIXEDDECIMAL is the number of
  299.       digits to the right of the decimal point.                               }
  300.       
  301.     {$ALIGN MAC68K}
  302.     Decform = RECORD
  303.         style:     DecimalKind;
  304.         digits: INTEGER;
  305.     END;
  306.     {$ALIGN RESET}
  307.     
  308. {    Each conversion to a decimal record d via the function call num2dec is 
  309.       controlled by a decform record f (defined earlier), to a double_t x.    }
  310. PROCEDURE num2dec({CONST}VAR f: Decform; x: double_t; VAR d: decimal); C; EXTERNAL;
  311.  
  312. { dec2num converts a decimal record d to a double_t value.          }
  313. FUNCTION dec2num({CONST}VAR d: Decimal): double_t; C; EXTERNAL;
  314.  
  315. {    The MathLib formatter dec2str is controlled by a decform f.  Input d is
  316.       a decimal record.                                                       }
  317. PROCEDURE dec2str({CONST}VAR f: Decform; {CONST}VAR d: Decimal; s: CStringPtr); C; EXTERNAL;
  318.  
  319. {    The function str2dec is the MathLib scanner.                            }
  320. PROCEDURE str2dec(s: ConstCStringPtr; VAR ix: INTEGER; VAR d: Decimal; VAR vp: INTEGER); C; EXTERNAL;
  321.  
  322. {$IFC GENERATING68K }
  323. {    dec2d is similar to dec2num except a double is returned on 68k platforms }
  324.     FUNCTION dec2d({CONST}VAR d: Decimal): Double; C; EXTERNAL;
  325. {$ENDC}
  326.  
  327. {    dec2f is similar to dec2num except a float is returned.                 }
  328. FUNCTION dec2f({CONST}VAR d: Decimal): Single; C; EXTERNAL;
  329.  
  330. {    dec2s is similar to dec2num except a short is returned.                 }
  331. FUNCTION dec2s({CONST}VAR d: Decimal): INTEGER; C; EXTERNAL;
  332.  
  333. {    dec2l is similar to dec2num except a long is returned.                  }
  334. FUNCTION dec2l({CONST}VAR d: Decimal): LONGINT; C; EXTERNAL;
  335.  
  336. (*******************************************************************************
  337. *                    68k-only Transfer Function Prototypes                     *
  338. *******************************************************************************)
  339.  
  340. {$IFC GENERATING68K }
  341.     PROCEDURE x96tox80({CONST}VAR x96: extended96; VAR x80: extended80); C; EXTERNAL;
  342.     PROCEDURE x80tox96({CONST}VAR x80: extended80; VAR x96: extended96); C; EXTERNAL;
  343. {$ENDC}     { GENERATING68K }
  344.  
  345.  
  346. {$ENDC} {__NOEXTENSIONS__}
  347.  
  348. (*******************************************************************************
  349. *                         PowerPC-only Function Prototypes                     *
  350. *******************************************************************************)
  351.  
  352. {$IFC GENERATINGPOWERPC }
  353. FUNCTION cosl(x: LongDouble): LongDouble; C; EXTERNAL;
  354. FUNCTION sinl(x: LongDouble): LongDouble; C; EXTERNAL;
  355. FUNCTION tanl(x: LongDouble): LongDouble; C; EXTERNAL;
  356. FUNCTION acosl(x: LongDouble): LongDouble; C; EXTERNAL;
  357. FUNCTION asinl(x: LongDouble): LongDouble; C; EXTERNAL;
  358. FUNCTION atanl(x: LongDouble): LongDouble; C; EXTERNAL;
  359. FUNCTION atan2l(y: LongDouble; x: LongDouble): LongDouble; C; EXTERNAL;
  360. FUNCTION coshl(x: LongDouble): LongDouble; C; EXTERNAL;
  361. FUNCTION sinhl(x: LongDouble): LongDouble; C; EXTERNAL;
  362. FUNCTION tanhl(x: LongDouble): LongDouble; C; EXTERNAL;
  363. FUNCTION acoshl(x: LongDouble): LongDouble; C; EXTERNAL;
  364. FUNCTION asinhl(x: LongDouble): LongDouble; C; EXTERNAL;
  365. FUNCTION atanhl(x: LongDouble): LongDouble; C; EXTERNAL;
  366. FUNCTION expl(x: LongDouble): LongDouble; C; EXTERNAL;
  367. FUNCTION expm1l(x: LongDouble): LongDouble; C; EXTERNAL;
  368. FUNCTION exp2l(x: LongDouble): LongDouble; C; EXTERNAL;
  369. FUNCTION frexpl(x: LongDouble; VAR exponent: LONGINT): LongDouble; C; EXTERNAL;
  370. FUNCTION ldexpl(x: LongDouble; n: LONGINT): LongDouble; C; EXTERNAL;
  371. FUNCTION logl(x: LongDouble): LongDouble; C; EXTERNAL;
  372. FUNCTION log1pl(x: LongDouble): LongDouble; C; EXTERNAL;
  373. FUNCTION log10l(x: LongDouble): LongDouble; C; EXTERNAL;
  374. FUNCTION log2l(x: LongDouble): LongDouble; C; EXTERNAL;
  375. FUNCTION logbl(x: LongDouble): LongDouble; C; EXTERNAL;
  376. FUNCTION scalbl(x: LongDouble; n: LONGINT): LongDouble; C; EXTERNAL;
  377. FUNCTION fabsl(x: LongDouble): LongDouble; C; EXTERNAL;
  378. FUNCTION hypotl(x: LongDouble; y: LongDouble): LongDouble; C; EXTERNAL;
  379. FUNCTION powl(x: LongDouble; y: LongDouble): LongDouble; C; EXTERNAL;
  380. FUNCTION sqrtl(x: LongDouble): LongDouble; C; EXTERNAL;
  381. FUNCTION erfl(x: LongDouble): LongDouble; C; EXTERNAL;
  382. FUNCTION erfcl(x: LongDouble): LongDouble; C; EXTERNAL;
  383. FUNCTION gammal(x: LongDouble): LongDouble; C; EXTERNAL;
  384. FUNCTION lgammal(x: LongDouble): LongDouble; C; EXTERNAL;
  385. FUNCTION ceill(x: LongDouble): LongDouble; C; EXTERNAL;
  386. FUNCTION floorl(x: LongDouble): LongDouble; C; EXTERNAL;
  387. FUNCTION rintl(x: LongDouble): LongDouble; C; EXTERNAL;
  388. FUNCTION nearbyintl(x: LongDouble): LongDouble; C; EXTERNAL;
  389. FUNCTION rinttoll(x: LongDouble): LONGINT; C; EXTERNAL;
  390. FUNCTION roundl(x: LongDouble): LongDouble; C; EXTERNAL;
  391. FUNCTION roundtoll(round: LongDouble): LONGINT; C; EXTERNAL;
  392. FUNCTION truncl(x: LongDouble): LongDouble; C; EXTERNAL;
  393. FUNCTION remainderl(x: LongDouble; y: LongDouble): LongDouble; C; EXTERNAL;
  394. FUNCTION remquol(x: LongDouble; y: LongDouble; VAR quo: LONGINT): LongDouble; C; EXTERNAL;
  395. FUNCTION copysignl(x: LongDouble; y: LongDouble): LongDouble; C; EXTERNAL;
  396. FUNCTION fdiml(x: LongDouble; y: LongDouble): LongDouble; C; EXTERNAL;
  397. FUNCTION fmaxl(x: LongDouble; y: LongDouble): LongDouble; C; EXTERNAL;
  398. FUNCTION fminl(x: LongDouble; y: LongDouble): LongDouble; C; EXTERNAL;
  399. FUNCTION modfl(x: LongDouble; VAR iptrl: LongDouble): LongDouble; C; EXTERNAL;
  400. FUNCTION nanl(tagp: ConstCStringPtr): LongDouble; C; EXTERNAL;
  401. FUNCTION nextafterl(x: LongDouble; y: LongDouble): LongDouble; C; EXTERNAL;
  402. FUNCTION __fpclassify(x: LongDouble): LONGINT; C; EXTERNAL;
  403. FUNCTION __isnormal(x: LongDouble): LONGINT; C; EXTERNAL;
  404. FUNCTION __isfinite(x: LongDouble): LONGINT; C; EXTERNAL;
  405. FUNCTION __isnan(x: LongDouble): LONGINT; C; EXTERNAL;
  406. FUNCTION __signbit(x: LongDouble): LONGINT; C; EXTERNAL;
  407.  
  408. {$IFC UNDEFINED __NOEXTENSIONS__ }
  409. FUNCTION relationl(x: LongDouble; y: LongDouble): relop; C; EXTERNAL;
  410. PROCEDURE x80told(x80: extended80; VAR x: LongDouble); C; EXTERNAL;
  411. PROCEDURE ldtox80(x: LongDouble; VAR x80: extended80); C; EXTERNAL;
  412.  
  413. {    MathLib v2 has two new transfer functions: x80tod and dtox80.  They can 
  414.       be used to directly transform 68k 80-bit extended data types to double
  415.       and back for PowerPC based machines without using the functions
  416.       x80told or ldtox80.  Double rounding may occur.                         
  417. }
  418. FUNCTION x80tod({CONST}VAR x80: extended80): Double; C; EXTERNAL;
  419. PROCEDURE dtox80({CONST}VAR x: Double; VAR x80: extended80); C; EXTERNAL;
  420.  
  421. PROCEDURE num2decl({CONST}VAR f: Decform; x: LongDouble; VAR d: Decimal); C; EXTERNAL;
  422. FUNCTION dec2numl({CONST}VAR d: Decimal): LongDouble; C; EXTERNAL;
  423. {$ENDC} { __NOEXTENSIONS__ }
  424.  
  425. {$ENDC} { GENERATINGPOWERPC }
  426.  
  427.  
  428.  
  429. {$SETC UsingIncludes := fpIncludes}
  430.  
  431. {$ENDC} {__FP__}
  432.  
  433. {$IFC NOT UsingIncludes}
  434.  END.
  435. {$ENDC}
  436.